<?php
define('ENCRYPTER_KEY', 'computer');

class CrypterComponent extends Component {
    /**
     * ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING !
     *
     * Do not change this key after we are in production unless you know what
     * the hell you are doing!!  If you change this key, no one can process
     * payments!
     *
     * If you want to change your key every so often, decrypt all the data that
     * has been previously encrypted and store as plain text somewhere, change
     * the key and then re-encrypt it.
     *
     * ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING ! WARNING !
     */
    var $key = ENCRYPTER_KEY;

    var $key_local_file = "B_B_B";

    var $name = "Crypter";
    /**
     * This function will encrypt the string that is passed to it
     *
     * @param String $data The string to be encrypted.
     * @return String Returns the encrypted string or false
     * @access public
     */
    function enCrypt($data = null) {
        if ($data != null) {
            // Make an encryption resource using a cipher
            $td = mcrypt_module_open('cast-256', '', 'ecb', '');
            // Create and encryption vector based on the $td size and random
            $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
            // Initialize the module using the resource, my key and the string vector
            mcrypt_generic_init($td, $this->key, $iv);
            // Encrypt the data using the $td resource
            $encrypted_data = mcrypt_generic($td, $data);
            // Encode in base64 for DB storage
            $encoded = base64_encode($encrypted_data);
            // Make sure the encryption modules get un-loaded
            if (!mcrypt_generic_deinit($td) || !mcrypt_module_close($td)) {
                $encoded = false;
            }
        } else {
            $encoded = false;
        }

        return str_replace( '/', '', $encoded);
    }
    /**
     * This function will de-crypt the string that is passed to it
     *
     * @param String $data The string to be encrypted.
     * @return String Returns the encrypted string or false
     */
    function deCrypt($data = null) {
        if ($data != null) {
            // The reverse of encrypt.  See that function for details
            $data = (string) base64_decode(trim($data));
            $td = mcrypt_module_open('cast-256', '', 'ecb', '');
            $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
            mcrypt_generic_init($td, $this->key, $iv);
            $data = (string) trim(mdecrypt_generic($td, $data));
            // Make sure the encryption modules get un-loaded
            if (!mcrypt_generic_deinit($td) || !mcrypt_module_close($td)) {
                $data = false;
            }
        } else {
            $data = false;
        }
        return $data;
    }

    /**
     * This method will mask a credit card number
     *
     * @param String $cardNumber The card number to be masked
     * @return String The masked card number
     * @access public
     */
    function maskCardNumber($cardNumber) {
        $cardArray = str_split($cardNumber);
        $length = count($cardArray);
        $maskedCardNumber = "";
        // Mask all numbers except the last 4
        for ($i = 0; $i < $length -4; $i++) {
            $cardArray[$i] = 'X';
        }
        // Turn back into a string
        for ($i = 0; $i < $length; $i++) {
            $maskedCardNumber = $maskedCardNumber . $cardArray[$i];
        }
        return $maskedCardNumber;
    }


    /**
     * Create url and add security code
     *
     * @param type  meta
     * @return type  meta
     * @access public
     */
    function createUrl( $url )
    {
        return $url . (string)$this->enCrypt( $url );
    }

    /**
     * Valid Url with code
     *
     * @param string - Url need valid
     * @return Bool true: ok; false: fail
     * @access public
     */
    function validUrl( $url ) {
        $tmp = split( '/', $url );

        $link = array( );

        for( $i = 0; $i <= 3; $i++ )
        {
            $link[] = array_shift( $tmp );
        }

        // get code
        $code = join( $tmp ,'/' );
        // Ecrypter
        $url = URL_BASE .  join( $link, '/' ) . '/';
        $code1 = $this->enCrypt( $url );

        return (bool) ($code === $code1);
    }

    //***************************************************************//
    // Function :
    //---------------------------------------------------------------//
    // Params   :
    //---------------------------------------------------------------//
    // Return   :
    //---------------------------------------------------------------//
    // Memo     :
    //---------------------------------------------------------------//
    // Version  :  Add ( SONY ) ( Dec 19, 2008 )
    //***************************************************************//
    function encode_local_file( $path = null )
    {
        if( strlen( $path ) > 0 )
        {
            $path = str_replace( "/", $this->key_local_file, $path );
        }
        return $path;
    }

    //***************************************************************//
    // Function :
    //---------------------------------------------------------------//
    // Params   :
    //---------------------------------------------------------------//
    // Return   :
    //---------------------------------------------------------------//
    // Memo     :
    //---------------------------------------------------------------//
    // Version  :  Add ( SONY ) ( Dec 19, 2008 )
    //***************************************************************//
    function decode_local_file( $path = null )
    {
        if( strlen( $path ) > 0 )
        {
            $path = str_replace( $this->key_local_file, "/", $path );
        }
        return $path;
    }

    /**
     * Translates a number to a short alhanumeric version
     *
     * Translated any number up to 9007199254740992
     * to a shorter version in letters e.g.:
     * 9007199254740989 --> PpQXn7COf
     *
     * specifiying the second argument true, it will
     * translate back e.g.:
     * PpQXn7COf --> 9007199254740989
     *
     * this function is based on any2dec && dec2any by
     * fragmer[at]mail[dot]ru
     * see: http://nl3.php.net/manual/en/function.base-convert.php#52450
     *
     * If you want the alphaID to be at least 3 letter long, use the
     * $pad_up = 3 argument
     *
     * In most cases this is better than totally random ID generators
     * because this can easily avoid duplicate ID's.
     * For example if you correlate the alpha ID to an auto incrementing ID
     * in your database, you're done.
     *
     * The reverse is done because it makes it slightly more cryptic,
     * but it also makes it easier to spread lots of IDs in different
     * directories on your filesystem. Example:
     * $part1 = substr($alpha_id,0,1);
     * $part2 = substr($alpha_id,1,1);
     * $part3 = substr($alpha_id,2,strlen($alpha_id));
     * $destindir = "/".$part1."/".$part2."/".$part3;
     * // by reversing, directories are more evenly spread out. The
     * // first 26 directories already occupy 26 main levels
     *
     * more info on limitation:
     * - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/165372
     *
     * if you really need this for bigger numbers you probably have to look
     * at things like: http://theserverpages.com/php/manual/en/ref.bc.php
     * or: http://theserverpages.com/php/manual/en/ref.gmp.php
     * but I haven't really dugg into this. If you have more info on those
     * matters feel free to leave a comment.
     *
     * @author  Kevin van Zonneveld <kevin@vanzonneveld.net>
     * @author  Simon Franz
     * @author  Deadfish
     * @copyright 2008 Kevin van Zonneveld (http://kevin.vanzonneveld.net)
     * @license   http://www.opensource.org/licenses/bsd-license.php New BSD Licence
     * @version   SVN: Release: $Id: alphaID.inc.php 344 2009-06-10 17:43:59Z kevin $
     * @link    http://kevin.vanzonneveld.net/
     *
     * @param mixed   $in    String or long input to translate
     * @param boolean $to_num  Reverses translation when true
     * @param mixed   $pad_up  Number or boolean padds the result up to a specified length
     * @param string  $passKey Supplying a password makes it harder to calculate the original ID
     *
     * @return mixed string or long
     */
    function alphaID($in, $to_num = false, $pad_up = false, $passKey = null)
    {

        $len = 5;
        $base='ABCDEFGHKLMNOPQRSTWXYZabcdefghjkmnpqrstwxyz123456789';
        $max=strlen($base)-1;
        $activatecode='';
        mt_srand((double)microtime()*1000000);
        while (strlen($activatecode)<$len+1)
          $activatecode.=$base{mt_rand(0,$max)};

        return $activatecode;

      $index = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      if ($passKey !== null) {
        // Although this function's purpose is to just make the
        // ID short - and not so much secure,
        // with this patch by Simon Franz (http://blog.snaky.org/)
        // you can optionally supply a password to make it harder
        // to calculate the corresponding numeric ID

        for ($n = 0; $n<strlen($index); $n++) {
          $i[] = substr( $index,$n ,1);
        }

        $passhash = hash('sha256',$passKey);
        $passhash = (strlen($passhash) < strlen($index))
          ? hash('sha512',$passKey)
          : $passhash;

        for ($n=0; $n < strlen($index); $n++) {
          $p[] =  substr($passhash, $n ,1);
        }

        array_multisort($p,  SORT_DESC, $i);
        $index = implode($i);
      }

      $base  = strlen($index);

      if ($to_num) {
        // Digital number  <<--  alphabet letter code
        $in  = strrev($in);
        $out = 0;
        $len = strlen($in) - 1;
        for ($t = 0; $t <= $len; $t++) {
          $bcpow = bcpow($base, $len - $t);
          $out   = $out + strpos($index, substr($in, $t, 1)) * $bcpow;
        }

        if (is_numeric($pad_up)) {
          $pad_up--;
          if ($pad_up > 0) {
            $out -= pow($base, $pad_up);
          }
        }
        $out = sprintf('%F', $out);
        $out = substr($out, 0, strpos($out, '.'));
      } else {
        // Digital number  -->>  alphabet letter code
        if (is_numeric($pad_up)) {
          $pad_up--;
          if ($pad_up > 0) {
            $in += pow($base, $pad_up);
          }
        }

        $out = "";
        for ($t = floor(log($in, $base)); $t >= 0; $t--) {
          $bcp = bcpow($base, $t);
          $a   = floor($in / $bcp) % $base;
          $out = $out . substr($index, $a, 1);
          $in  = $in - ($a * $bcp);
        }
        $out = strrev($out); // reverse
      }

      return $out;
    }
}

/**
 * Create encrypt code for view image or static file in mongo
 *
 * @param string - id need view
 * @access public
 */
function EncrypterForView($id, $model, $download = false)
{
    $url = $model .'='. $id . '&e=' . md5($id. SECURITY_CODE );

    // for download
    if( $download )
    {
        $url .= "&m=download";
    }

    return $url;
}
?>